package com.anpy.album.service.impl;

import com.anpy.album.dto.CalendarEventDTO;
import com.anpy.album.entity.CalendarEvent;
import com.anpy.album.mapper.CalendarEventMapper;
import com.anpy.album.service.CalendarEventService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 日历事件服务实现类
 */
@Service
public class CalendarEventServiceImpl implements CalendarEventService {

    @Autowired
    private CalendarEventMapper calendarEventMapper;

    /**
     * 创建日历事件
     *
     * @param eventDTO 日历事件DTO
     * @return 创建的日历事件
     */
    @Override
    @Transactional
    public CalendarEventDTO createEvent(CalendarEventDTO eventDTO) {
        CalendarEvent event = convertToEntity(eventDTO);
        calendarEventMapper.insert(event);
        return convertToDTO(event);
    }

    /**
     * 更新日历事件
     *
     * @param eventDTO 日历事件DTO
     * @return 更新后的日历事件
     */
    @Override
    @Transactional
    public CalendarEventDTO updateEvent(CalendarEventDTO eventDTO) {
        CalendarEvent event = convertToEntity(eventDTO);
        calendarEventMapper.updateById(event);
        return convertToDTO(calendarEventMapper.selectById(event.getId()));
    }

    /**
     * 删除日历事件
     *
     * @param id 事件ID
     * @return 是否删除成功
     */
    @Override
    @Transactional
    public boolean deleteEvent(Long id) {
        return calendarEventMapper.deleteById(id) > 0;
    }

    /**
     * 根据ID获取日历事件
     *
     * @param id 事件ID
     * @return 日历事件DTO
     */
    @Override
    public CalendarEventDTO getEventById(Long id) {
        CalendarEvent event = calendarEventMapper.selectById(id);
        return event != null ? convertToDTO(event) : null;
    }

    /**
     * 根据用户ID获取所有日历事件
     *
     * @param userId 用户ID
     * @return 日历事件DTO列表
     */
    @Override
    public List<CalendarEventDTO> getEventsByUserId(Long userId) {
        List<CalendarEvent> events = calendarEventMapper.selectByUserId(userId);
        return convertToDTOList(events);
    }

    /**
     * 根据用户ID和时间范围获取日历事件
     *
     * @param userId    用户ID
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 日历事件DTO列表
     */
    @Override
    public List<CalendarEventDTO> getEventsByUserIdAndTimeRange(Long userId, LocalDateTime startTime, LocalDateTime endTime) {
        List<CalendarEvent> events = calendarEventMapper.selectByUserIdAndTimeRange(userId, startTime, endTime);
        return convertToDTOList(events);
    }

    /**
     * 根据用户ID和事件类型获取日历事件
     *
     * @param userId    用户ID
     * @param eventType 事件类型
     * @return 日历事件DTO列表
     */
    @Override
    public List<CalendarEventDTO> getEventsByUserIdAndEventType(Long userId, Integer eventType) {
        List<CalendarEvent> events = calendarEventMapper.selectByUserIdAndEventType(userId, eventType);
        return convertToDTOList(events);
    }

    /**
     * 根据用户ID获取指定日期的日历事件
     *
     * @param userId 用户ID
     * @param date   日期
     * @return 日历事件DTO列表
     */
    @Override
    public List<CalendarEventDTO> getEventsByUserIdAndDate(Long userId, LocalDateTime date) {
        List<CalendarEvent> events = calendarEventMapper.selectByUserIdAndDate(userId, date);
        return convertToDTOList(events);
    }

    /**
     * 将实体对象转换为DTO对象
     *
     * @param event 日历事件实体
     * @return 日历事件DTO
     */
    private CalendarEventDTO convertToDTO(CalendarEvent event) {
        if (event == null) {
            return null;
        }
        
        CalendarEventDTO dto = new CalendarEventDTO();
        BeanUtils.copyProperties(event, dto);
        
        // 设置事件类型名称
        dto.setEventTypeName(getEventTypeName(event.getEventType()));
        
        // 处理参与者列表
        if (StringUtils.hasText(event.getParticipants())) {
            dto.setParticipantList(Arrays.asList(event.getParticipants().split(",")));
        } else {
            dto.setParticipantList(new ArrayList<>());
        }
        
        return dto;
    }

    /**
     * 将DTO对象转换为实体对象
     *
     * @param dto 日历事件DTO
     * @return 日历事件实体
     */
    private CalendarEvent convertToEntity(CalendarEventDTO dto) {
        if (dto == null) {
            return null;
        }
        
        CalendarEvent event = new CalendarEvent();
        BeanUtils.copyProperties(dto, event);
        
        // 处理参与者字符串
        if (dto.getParticipantList() != null && !dto.getParticipantList().isEmpty()) {
            event.setParticipants(String.join(",", dto.getParticipantList()));
        } else if (StringUtils.hasText(dto.getParticipants())) {
            event.setParticipants(dto.getParticipants());
        }
        
        return event;
    }

    /**
     * 将实体列表转换为DTO列表
     *
     * @param events 日历事件实体列表
     * @return 日历事件DTO列表
     */
    private List<CalendarEventDTO> convertToDTOList(List<CalendarEvent> events) {
        if (events == null) {
            return new ArrayList<>();
        }
        return events.stream().map(this::convertToDTO).collect(Collectors.toList());
    }

    /**
     * 获取事件类型名称
     *
     * @param eventType 事件类型代码
     * @return 事件类型名称
     */
    private String getEventTypeName(Integer eventType) {
        if (eventType == null) {
            return "其他";
        }
        
        switch (eventType) {
            case 0:
                return "生日";
            case 1:
                return "游玩";
            case 2:
                return "看病";
            case 3:
                return "纪念日";
            case 4:
                return "家庭聚会";
            case 5:
                return "学习";
            case 6:
            default:
                return "其他";
        }
    }
}
